Visualización de datos

Visualizar datos multidimensionales es tanto un arte como una ciencia. Debido a las limitaciones de nuestros dispositivos de representación bidimensional (2-D), construir visualizaciones efectivas con más de dos dimensiones de datos (atributos o características) se vuelve desafiante a medida que el número de dimensiones aumenta.

La visualización de datos y la narración siempre ha sido una de las fases más importantes de cualquier proyecto de ciencia de datos que involucre la extracción de ideas significativas de los datos, independientemente de la complejidad de los datos o del proyecto.

Ten en cuenta la siguiente recomendación: "No confíes ciegamente en tus datos y comiences a modelar en tus datos". Las estadísticas resumidas siempre pueden resultar engañosas. Siempre visualiza y comprende las características de tus datos antes de pasar a la ingeniería de características y la construcción de modelos estadísticos, de aprendizaje automático y de aprendizaje profundo.

Gramática de Gráficos para una visualización efectiva se refiere a un enfoque sistemático y estructurado para la creación de visualizaciones de datos. La "Grammar of Graphics" (Gramática de Gráficos) es un concepto introducido por Leland Wilkinson en su libro "The Grammar of Graphics", donde propone una gramática unificada para describir y construir gráficos de manera efectiva.

La idea central de la Gramática de Gráficos es que las visualizaciones pueden ser desglosadas en componentes fundamentales que pueden ser combinados y personalizados para crear una variedad de gráficos complejos. Wilkinson argumenta que hay elementos comunes subyacentes a todos los gráficos y que identificar y comprender estos elementos permite construir visualizaciones de manera más efectiva.

Los componentes básicos de la Gramática de Gráficos incluyen:

1. Datos: La información que se va a visualizar.

2. Estética: Atributos visuales como color, forma, tamaño, etc., que se aplican a los datos.

3. Geometría: La forma básica del gráfico, como puntos, líneas, barras, etc.

1. Facetas: La subdivisión del gráfico en paneles o subgráficos, generalmente basados en variables categóricas.

2. Coordinadas: El sistema de ejes y escalas utilizado para representar los datos.

3. Estadísticas: Resúmenes estadísticos o transformaciones aplicadas a los datos antes de visualizarlos.

Al seguir la Gramática de Gráficos, los analistas y científicos de datos pueden construir visualizaciones de manera más consistente y comprensible. Se facilita la comunicación de información visual, y se pueden adaptar los principios de la gramática a diversas herramientas de visualización.

Librerías populares como ggplot2 en R y la implementación de Gramática de Gráficos en ggplot en Python (parte de la biblioteca plotnine) se basan en estos principios. Estas herramientas permiten a los usuarios crear visualizaciones complejas y personalizadas aplicando los conceptos de la Gramática de Gráficos.

Seaborn no se basa directamente en la "Grammar of Graphics" (Gramática de Gráficos) como lo hace la biblioteca ggplot2 en R. En cambio, Seaborn se centra en simplificar la creación de visualizaciones estadísticas atractivas y comprensibles mediante la aplicación de estilos y patrones de diseño específicos.

Mientras que la Gramática de Gráficos propone una estructura más modular y generalizada para construir visualizaciones, Seaborn se enfoca en abordar casos comunes de visualización estadística y proporcionar una interfaz sencilla para la creación de gráficos complejos.

Por otro lado, en Python, plotnine es una biblioteca que implementa la Gramática de Gráficos y busca proporcionar una experiencia similar a ggplot2 en R. Plotnine se basa directamente en los principios de la Gramática de Gráficos y proporciona una manera estructurada y consistente de crear gráficos.

En resumen, aunque Seaborn no está basado directamente en la Gramática de Gráficos, tiene como objetivo hacer que la creación de visualizaciones sea más accesible y estilizada, mientras que plotnine en Python está más alineado con los principios de la Gramática de Gráficos.

Fuentes y recursos

• John Guerra, Visual Analytics

• Visualization Notebooks in Kaggle

• Grammar of Graphics

Ejemplos prácticos de visualización

• A continuación construiremos gráficos comunes que nos pueden ser útiles en un análisis multivariado de datos.
  • Se proporiciona un script viz.py que podemos reutilizar en nuestros proyectos.

Visualización de un dataset de usabilidad

Una organización ambiental ha desarrollado una nueva aplicación móvil para monitorear la calidad del aire en diferentes áreas urbanas. Tras el lanzamiento de la aplicación, recibieron comentarios diversos por parte de los usuarios sobre su usabilidad. Algunos usuarios encuentran la aplicación fácil de usar y útil para acceder a información sobre la calidad del aire, mientras que otros experimentan dificultades al navegar por la interfaz y entender los datos proporcionados.

Para evaluar la usabilidad de la aplicación de calidad del aire, la organización decide utilizar el Computer System Usability Questionnaire (CSUQ). Este cuestionario es una herramienta estándar ampliamente utilizada para evaluar la usabilidad percibida de los sistemas informáticos y se compone de múltiples ítems diseñados para medir diferentes aspectos de la usabilidad, como la facilidad de aprendizaje, la eficiencia, la satisfacción del usuario y la facilidad de uso general.

El CSUQ se administra a una muestra de usuarios que han utilizado la aplicación móvil de calidad del aire. Cada usuario responde a preguntas sobre su experiencia utilizando la aplicación, calificando cada ítem en una escala de Likert de 1 a 7, donde 1 representa "muy difícil" o "muy insatisfactorio" y 7 representa "muy fácil" o "muy satisfactorio".

Después de recopilar los datos del CSUQ de los usuarios, la organización realiza un análisis para evaluar la usabilidad de la aplicación de calidad del aire. Utilizan técnicas estadísticas para calcular puntajes promedio en cada ítem del CSUQ, así como puntajes globales de usabilidad. Además, pueden realizar análisis comparativos entre diferentes grupos de usuarios (por ejemplo, usuarios de diferentes edades o niveles de experiencia tecnológica) para identificar posibles diferencias en la usabilidad percibida de la aplicación.

Con los resultados del CSUQ y el análisis estadístico, la organización puede identificar áreas específicas de mejora en el diseño y la funcionalidad de la aplicación de calidad del aire. Estos hallazgos pueden utilizarse para realizar ajustes y mejoras en la aplicación con el objetivo de mejorar la experiencia del usuario y garantizar un acceso más fácil y efectivo a la información sobre la calidad del aire en las áreas urbanas.

El Computer System Usability Questionnaire (CSUQ) es una herramienta ampliamente utilizada para evaluar la usabilidad percibida de los sistemas informáticos. Consta de varios elementos o subescalas diseñados para medir diferentes aspectos de la usabilidad. Aquí están los elementos principales del CSUQ:

1. SYSUSE (Uso del sistema, 8 preguntas): Esta subescala evalúa la facilidad con la que los usuarios pueden realizar tareas específicas utilizando el sistema. Incluye ítems que abordan la facilidad de navegación, la claridad de las instrucciones y la eficiencia en la realización de tareas.

2. INFOQUAL (Calidad de la información, 7 preguntas): Esta subescala se centra en la calidad de la información proporcionada por el sistema. Evalúa si la información presentada es clara, precisa y relevante para las necesidades del usuario.

3. INTERQUAL (Calidad de la interacción, 3 preguntas): Esta subescala se refiere a la calidad de la interacción del usuario con el sistema. Evalúa aspectos como la capacidad de respuesta del sistema, la facilidad de comunicación y la amigabilidad del sistema en general.

4. OVERALL (General, 1 pregunta): Esta subescala proporciona una evaluación general de la usabilidad del sistema. Los ítems en esta subescala pueden abordar la satisfacción general del usuario, la facilidad de uso percibida y la disposición del usuario para utilizar el sistema en el futuro.

Cada elemento del CSUQ consta de varios ítems o preguntas que los usuarios responden utilizando una escala de Likert, donde puntúan su acuerdo o desacuerdo con las afirmaciones relacionadas con ese elemento. Los puntajes obtenidos en cada elemento se utilizan para calcular puntajes globales de usabilidad y proporcionar una evaluación integral de la usabilidad del sistema informático.

Revise:

• https://garyperlman.com/quest/quest.cgi

Análisis exploratorio

En la investigación de experiencia de usuario (UX), es común recopilar tanto información categórica como numérica para comprender mejor el comportamiento y las preferencias de los usuarios. Aquí hay una descripción general de qué tipo de información se suele recopilar en cada categoría:

1. Información Categórica:

   • Demográfica: Datos como edad, género, nivel educativo, ocupación, ubicación geográfica, etc.
   • Hábitos y preferencias: Preferencias de productos, intereses, actividades, comportamientos de compra, etc.
   • Opiniones y comentarios: Respuestas a preguntas abiertas, comentarios, sugerencias, calificaciones de satisfacción, etc.
   • Datos del usuario: Tipo de dispositivo, sistema operativo, navegador web, preferencias de configuración, etc.
   • Segmentación de usuarios: Agrupación de usuarios en segmentos basados en características similares para análisis específicos.

2. Información Numérica:

   • Mediciones de tiempo: Tiempo de interacción con una interfaz, duración de una tarea, tiempo de carga de una página, etc.
   • Puntuaciones y calificaciones: Puntuaciones en escalas de Likert para evaluar la usabilidad, la satisfacción del usuario, la facilidad de uso, etc.
   • Datos de rendimiento: Velocidad de respuesta de la aplicación, tasas de conversión, métricas de retención de usuarios, etc.
   • Datos cuantitativos de uso: Número de clics, páginas vistas, acciones realizadas, errores encontrados, etc.
   • Datos de comportamiento: Patrones de navegación, rutas de usuarios, flujo de interacciones, etc.

Es importante recopilar una combinación de información categórica y numérica para obtener una comprensión completa del comportamiento y las necesidades de los usuarios en un entorno digital. Esto permite a los investigadores y diseñadores de UX tomar decisiones informadas sobre el diseño y la optimización de productos y servicios para mejorar la experiencia del usuario.

Información categórica

La representación gráfica del siguiente diagrama de barras con dos variables categóricas muestra claramente la distribución del grupo de edad para cada tipo de género. Un diagrama tipo heatmap también puede ser útil para mostrar estas frecuencias.

Información numérica y categórica

Un diagrama de violín con dos variables categóricas para agrupar, una en el eje x y otra en el parámetro "hue", representa la distribución de una variable numérica en función de dos variables categóricas. En el siguiente ejemplo se muestra la distribución de la experiencia en el uso de computadores (numérica) de acuerdo al género del usuario (categórica) y al nivel de educación (categórica).

Gráficos categóricos (catplot)

La función catplot de seaborn permite generar una variedad de gráficos. A continuación se muestran los valores numéricos, respuestas dadas la pregunta 08 del CSUQ en el eje $x$. En el eje $y$ se representa la variable categórica nivel de educación. Se realiza un faceting usando la variable categórica género, separando las observaciones en paneles de acuerdo a las categorías de esta variable {Male, Female}. Una tercera variable categórica representada por el color de los puntos corresponde al grupo de edad de los entrevistados.

Ejecute el script usando el código en la siguiente celda para replicar los gráficos arriba y explore gráficos adicionales.

from viz import *

all_data = {}

# Load data with demographics
data_demo = pd.read_csv("https://raw.githubusercontent.com/marsgr6/estadistica-ux/main/data/demo_ux.csv")
# trim columns names
data_demo.columns = data_demo.columns.str[:48]

# Load data with survey
# Use first column as index, and remove last column
data_csuq = pd.read_csv("https://raw.githubusercontent.com/marsgr6/estadistica-ux/main/data/csuq_ux.csv", index_col=0).iloc[:,:-1]
# Add columns from demographic data
data_csuq["Gender"] = data_demo.iloc[:, 1]
data_csuq["Age"] = data_demo.iloc[:, 2]
data_csuq["Education"] = data_demo.iloc[:, 3]

# Melt data
datam = data_csuq.melt(id_vars=["Gender", "Age", "Education"])
n_obs = data_csuq.shape[0]  # number of observations in data

# Four categories, n_obs x num_preguntas para cada categoria
factor = ['SYSUSE']*n_obs*8 + ['INFOQUAL']*n_obs*7 + ['INTERQUAL']*n_obs*3 + ['OVERALL']*n_obs
# Categorias (factor) CSUQ
datam["factor"] = factor

# Add dataframes to data dictionary
all_data['UX_demo'] = data_demo
all_data['CSUQ_questionnaire'] = data_csuq
all_data['CSUQ_melted'] = datam

# call the function to perform EDA from viz.py passing the dictionary
plot_data(all_data)

interactive(children=(Dropdown(description='ds', options=('UX_demo', 'CSUQ_questionnaire', 'CSUQ_melted'), val…

Visualizando respuestas por categoría en el CSUQ

Un gráfico de barras apiladas, también conocido como gráfico de barras segmentado o gráfico de barras dividido, se utiliza para mostrar información categorizada en una escala Likert de 7 puntos. En este tipo de gráfico, cada barra representa una categoría y está dividida en segmentos que corresponden a los diferentes niveles de la escala Likert. Cada segmento está coloreado de manera distinta para representar los diferentes niveles de la escala, lo que permite visualizar la distribución de respuestas para cada categoría. Este gráfico proporciona una forma efectiva de comparar las respuestas en cada nivel de la escala Likert entre diferentes categorías.

sns.set_theme(style="white")
cross_tab_prop = pd.crosstab(index=datam['factor'],
                             columns=datam['value'],
                             normalize="index")

cross_tab_prop = cross_tab_prop[cross_tab_prop.columns[::-1]]

cross_tab_prop = cross_tab_prop.reindex(['SYSUSE', 'INFOQUAL', 'INTERQUAL', 'OVERALL'])

my_colors = list(['blue', 'cornflowerblue', 'g', 'gray', 'y', 'orange', 'red'])

cross_tab_prop.plot(kind='barh',
                        stacked=True,
                        #colormap='Set3',
                        color=my_colors,
                        figsize=(16, 6))

plt.legend(loc="lower left", ncol=2)
#plt.ylabel("Release Year")
#plt.xlabel("Proportion")


for n, x in enumerate([*cross_tab_prop.index.values]):
    for (proportion, count, y_loc) in zip(cross_tab_prop.loc[x],
                                          cross_tab_prop.loc[x],
                                          cross_tab_prop.loc[x].cumsum()):

        plt.text(x=(y_loc - proportion) + (proportion / 2) - 0.01,
                 y=n - 0.05,
                 s=f'{np.round(proportion * 100, 1)}%',
                 color="white",
                 fontsize=10,
                 fontweight="bold")

legend_labels = ['Strongly disagree', 'Disagree', 'Somewhat disagree', 'Neutral', 'Somewhat agree', 'Agree', 'Strongly agree']
plt.legend(labels = legend_labels, bbox_to_anchor=(1.04, 1), loc="upper left")
plt.show()

Barras por pregunta

• Si tenemos interés en resumir cada pregunta de forma individual podemos replicar el diagrama anterior, esta vez sin agrupar por categoría del CSUQ.

sns.set_theme(style="white")
cross_tab_prop = pd.crosstab(index=datam['variable'],
                             columns=datam['value'],
                             normalize="index")

cross_tab_prop = cross_tab_prop[cross_tab_prop.columns[::-1]]

cross_tab_prop["Question"] = ['Q'+str(i+1) for i in range(19)]
cross_tab_prop = cross_tab_prop.set_index("Question")

my_colors = list(['blue', 'cornflowerblue', 'g', 'gray', 'y', 'orange', 'red'])

cross_tab_prop.plot(kind='barh',
                        stacked=True,
                        #colormap='Set3',
                        color=my_colors,
                        figsize=(16, 10))

plt.legend(loc="lower left", ncol=2)
#plt.ylabel("Release Year")
#plt.xlabel("Proportion")


for n, x in enumerate([*cross_tab_prop.index.values]):
    for (proportion, count, y_loc) in zip(cross_tab_prop.loc[x],
                                          cross_tab_prop.loc[x],
                                          cross_tab_prop.loc[x].cumsum()):

        plt.text(x=(y_loc - proportion) + (proportion / 2) - 0.01,
                 y=n - 0.05,
                 s=f'{np.round(proportion * 100, 1)}%',
                 color="white",
                 fontsize=10,
                 fontweight="bold")

legend_labels = ['Strongly disagree', 'Disagree', 'Somewhat disagree', 'Neutral', 'Somewhat agree', 'Agree', 'Strongly agree']
plt.legend(labels = legend_labels, bbox_to_anchor=(1.04, 1), loc="upper left")
plt.show()

 Análisis de clustering

A partir de nuestro dataset de usabilidad podemos construir clusters jerárquicos usando solamente las columnas numéricas correspondientes a la respuestas del questionario CSUQ (escala de 1 a 7).

El resultado para $c=2$ clusters se muestra en el dendrograma a continuación.

Ejecute el código a continuación para poder ver los resultados para $clusters=\{2,3,4,5\}$.

from sklearn.cluster import AgglomerativeClustering
import scipy.cluster.hierarchy as shc
from scipy.cluster.hierarchy import linkage, dendrogram, fcluster
from scipy.spatial.distance import squareform
from sklearn.impute import KNNImputer

# Remove missing values using KNNImputer
data_cl = data_csuq.iloc[:,:-3]  # datos numéricos
imputer = KNNImputer(n_neighbors=2)  # define inputer
imputer.fit_transform(data_cl)  # reemplaza valores faltantes

df = data_cl.copy()

Z=shc.linkage(data_cl, method='ward')

def fancy_dendrogram(*args, **kwargs):
    max_d = kwargs.pop('max_d', None)
    if max_d and 'color_threshold' not in kwargs:
        kwargs['color_threshold'] = max_d
    annotate_above = kwargs.pop('annotate_above', 0)

    ddata = dendrogram(*args, **kwargs)

    if not kwargs.get('no_plot', False):
        plt.title('Hierarchical Clustering Dendrogram (truncated)')
        plt.xlabel('sample index or (cluster size)')
        plt.ylabel('distance')
        for i, d, c in zip(ddata['icoord'], ddata['dcoord'], ddata['color_list']):
            x = 0.5 * sum(i[1:3])
            y = d[1]
            if y > annotate_above:
                plt.plot(x, y, 'o', c=c)
                plt.annotate("%.3g" % y, (x, y), xytext=(0, -5),
                             textcoords='offset points',
                             va='top', ha='center')
        if max_d:
            plt.axhline(y=max_d, c='k')

    return ddata

d = [32, 20, 14.2, 12.9]

@ipywidgets.interact
def plot(Clusters=[2, 3, 4, 5]):
    cluster = AgglomerativeClustering(n_clusters=Clusters, metric='euclidean', linkage='ward')
    labels = cluster.fit_predict(data_cl)
    df['cluster'] = labels.astype('str')
    df['cluster'] = df['cluster'].astype("category")
    print(np.unique(labels, return_counts=True))

    plt.figure(figsize=(12, 8))
    fancy_dendrogram(
        Z,
        #truncate_mode='lastp',
        p=12,
        leaf_rotation=90.,
        leaf_font_size=12.,
        show_contracted=True,
        annotate_above=10,
        max_d=d[Clusters-2],
    );
    plt.show()

interactive(children=(Dropdown(description='Clusters', options=(2, 3, 4, 5), value=2), Output()), _dom_classes…

 Visualizando los clusters

Debemos entender los clusters a partir de describir los datos agrupados de acuerdo a esta nueva variable categórica correspondiente a la asignación de nuestras observaciones a cada uno de los clusters.

El gráfico a continuación nos da una mirada rápida de los valores respondidos por categoría de cada uno de los usarios representados por los puntos, coloreados de acuerdo al clúster correspondidnte. Además agregamos un lineplot para cada categoría y para cada número de clusters para comparar.

Podemos observar que los usuarios pertenecientes al cluster 0 está dando respuestas más bajas.

Actividad: Utilice el código a continuación para realizar un análisis exploratorio de acuerdo a los clusters y describa las características de cada uno.

from scipy.stats import uniform
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)

def jitter(x):
    return x + uniform.rvs(0, .5) -.25

# data preparation
df1 = data_cl.copy()  # copiamos el dataset con datos numéricos
df1["Education"] = data_csuq.Education  # Agregamos variables demográficas
df1["Age"] = data_csuq.Age
df1["Gender"] = data_csuq.Gender
df1["cluster"] = df.cluster  # Agregamos clusters generados
# melt del dataset
df_m1 = df1.melt(id_vars=["Gender", "Age", "Education", "cluster"])
n_obs = df1.shape[0]  # number of observations in data
# Agregamos categorías CSUQ
# Four categories, n_obs x num_preguntas para cada categoria
factor = ['SYSUSE']*n_obs*8 + ['INFOQUAL']*n_obs*7 + ['INTERQUAL']*n_obs*3 + ['OVERALL']*n_obs
df_m1["factor"] = factor  # Categorias CSUQ

type_ids = {'SYSUSE': 0, 'INFOQUAL': 1, 'INTERQUAL': 2, 'OVERALL': 3}


@ipywidgets.interact
def plot(var_x=['factor', 'Gender', 'Age', 'Education'],
         var_y=['value'],
         hue=['cluster', 'factor', 'Gender', 'Age', 'Education'],
         ci=[95, 68, 99],
         include_points=True
        ):

    ax = sns.relplot(
        data=df_m1, x=var_x, y=var_y,
        hue=hue, style=hue, kind="line", err_style="bars", errorbar=('ci', ci),
        height=6, aspect=1.25, linewidth=2
    )
    if include_points:
        df_m1['type_id'] = df_m1['factor'].apply(lambda x: type_ids[x])
        df_m1['jitter_type'] = df_m1['type_id'].apply(lambda x: jitter(x))
        df_m1['jitter_value'] = df_m1['value'].apply(lambda x: jitter(x))

        ax=sns.scatterplot(data=df_m1, x='jitter_type', y='jitter_value', hue=hue, alpha=0.35)
        handles, labels = ax.get_legend_handles_labels()
        ax.legend(handles[2:], labels[2:])
    plt.show()

interactive(children=(Dropdown(description='var_x', options=('factor', 'Gender', 'Age', 'Education'), value='f…

 Análsis de texto

En el estudio de usabilidad se le pidió a los usuarios que seleccionaran las palabras que mejor describían el sistema. A partir de las palabras seleccionadas por cada usuario se visualiza los términos seleccionados, ordenados de acuerdo a su frecuencia.

# data with words selected by users 
data_words = pd.read_csv("https://raw.githubusercontent.com/marsgr6/estadistica-ux/main/data/words_ux.csv")
data_words.head()

	Words
0	Boring Consistent EasyToUse Fast Simple Useful
1	Boring Confusing Contradictory Difficult EasyT...
2	Confusing Fast Old Unattractive Useful
3	Complex Confusing Creative Difficult
4	Advanced Clean Credible Difficult Effective New

# get each row, list of user selected words
user_answers = [answer.split() for answer in data_words.Words]
# get all words
all_words = [word for words in user_answers for word in words]

unique_words, words_frequency = np.unique(all_words, return_counts = True)

df = pd.DataFrame({"words": unique_words, "frequency": words_frequency})
df = df.sort_values(by="frequency", ascending=False)

# plot word frequency
sns.set_context("paper")
plt.figure(figsize=(16,8))
g = sns.barplot(data=df, x="words", y="frequency");
plt.xticks(rotation=90)
plt.show()

A partir de las palabras seleccionadas por cada usuario se construyó la matriz de términos de documentos.

Una matriz de términos de documentos (DTM, por sus siglas en inglés Document-Term Matrix) es una representación de documentos de texto en forma de una matriz, donde las filas representan documentos y las columnas representan términos (palabras o tokens). Cada celda de la matriz contiene el recuento de ocurrencias de un término en un documento específico.

En otras palabras, una DTM es una estructura de datos que permite analizar y procesar documentos de texto de una manera numérica, lo que facilita la aplicación de técnicas de aprendizaje automático y minería de textos para tareas como clasificación de documentos, agrupamiento de temas, análisis de sentimientos, entre otros.

incidence_matrix = pd.DataFrame(data=np.zeros((len(user_answers),len(unique_words)), dtype=int), columns=unique_words)

for user, answer in enumerate(user_answers):
    for word in answer:
        incidence_matrix[word][user] += 1

plt.figure(figsize=(16,6))
sns.heatmap(incidence_matrix, cbar=False, square=False, cmap='gray')
plt.show()

words_correlation = incidence_matrix.corr()
sns.clustermap(words_correlation, figsize=(20,20), vmin=-1, vmax=1)
plt.show()

Podemos representar la matriz de correlación como un grafo y aplicar técnicas de clustering (detección de comunidades) para encontrar grupos de palabras que puedan considerarse como tópicos.

1. Representar la matriz de correlación como un grafo: Cada término en la DTM se convierte en un nodo en el grafo. La correlación entre los términos determina el peso de las aristas entre los nodos. Puedes utilizar bibliotecas de visualización de redes como NetworkX en Python para crear y visualizar el grafo.

2. Trimming de acuerdo al valor del edge weight: Define un umbral para los valores de correlación que considerarás como conexiones significativas entre términos. Esto te ayudará a reducir el ruido en el grafo y a centrarte en las relaciones más fuertes entre los términos. Puedes eliminar las aristas cuyo peso esté por debajo de este umbral.

3. Aplicar técnicas de clustering en la red: Una vez que tengas el grafo, puedes aplicar técnicas de clustering como el algoritmo de Louvain o el algoritmo de Girvan-Newman para detectar comunidades de términos altamente correlacionados. Estas comunidades representarán grupos de palabras que están estrechamente relacionadas entre sí en términos de su ocurrencia y contexto en los documentos.

4. Análisis de los grupos de palabras: Examina los grupos de palabras identificados por el clustering para determinar si representan temas coherentes o tópicos dentro del corpus de documentos. Puedes utilizar medidas como la frecuencia de ocurrencia de palabras clave y la interpretación semántica de los términos para caracterizar y etiquetar los grupos encontrados.

Al seguir estos pasos, podrás utilizar la matriz de correlación como una herramienta para identificar y explorar los tópicos presentes en el conjunto de documentos. Esto puede ser útil para tareas como la extracción automática de tópicos, la organización de documentos y la comprensión de la estructura temática de un corpus de texto.

A continuación se muestra la red, de manera autónoma intenta detectar comunidades (tópicos).

Requerimientos:

!pip install pygraphviz
!pip install netgraph

Modelado de tópicos

• Identificaremos tópicos usando dos medidas: Correlación entre palabras y similitud de Jaccard.

from sklearn.metrics import jaccard_score

# Calculate jaccard similarity matrix
jaccard_similarity = pd.DataFrame(np.zeros((len(unique_words), len(unique_words))), 
                                  index=incidence_matrix.columns, 
                                  columns=incidence_matrix.columns)

for word_i in incidence_matrix.columns:
    for word_j in incidence_matrix.columns:
        jaccard_similarity[word_i][word_j] = jaccard_score(incidence_matrix[word_i], 
                                                           incidence_matrix[word_j])
jaccard_similarity

	Advanced	Ambiguous	Attractive	Boring	Bright	Busy	Clean	Clear	Complex	Comprehensive	...	Too-technical	Trustworthy	Unattractive	Unconventional	Understandable	Unpredictable	Unrefined	Usable	Useful	Vague
Advanced	1.000000	0.034483	0.560000	0.000000	0.045455	0.043478	0.384615	0.300000	0.136364	0.230769	...	0.181818	0.000000	0.038462	0.047619	0.000000	0.047619	0.045455	0.259259	0.258065	0.00
Ambiguous	0.034483	1.000000	0.080000	0.142857	0.000000	0.090909	0.043478	0.125000	0.000000	0.000000	...	0.166667	0.111111	0.153846	0.000000	0.000000	0.000000	0.100000	0.000000	0.038462	0.20
Attractive	0.560000	0.080000	1.000000	0.064516	0.052632	0.050000	0.178571	0.333333	0.047619	0.208333	...	0.210526	0.000000	0.043478	0.000000	0.000000	0.055556	0.000000	0.240000	0.285714	0.05
Boring	0.000000	0.142857	0.064516	1.000000	0.000000	0.058824	0.071429	0.178571	0.000000	0.083333	...	0.000000	0.000000	0.166667	0.000000	0.000000	0.000000	0.062500	0.120000	0.137931	0.20
Bright	0.045455	0.000000	0.052632	0.000000	1.000000	0.000000	0.062500	0.111111	0.200000	0.000000	...	0.166667	0.000000	0.000000	0.000000	0.000000	0.500000	0.000000	0.071429	0.111111	0.00
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
Unpredictable	0.047619	0.000000	0.055556	0.000000	0.500000	0.000000	0.066667	0.055556	0.250000	0.000000	...	0.200000	0.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.076923	0.055556	0.00
Unrefined	0.045455	0.100000	0.000000	0.062500	0.000000	0.250000	0.062500	0.052632	0.200000	0.000000	...	0.000000	0.000000	0.142857	0.500000	0.000000	0.000000	1.000000	0.000000	0.000000	0.25
Usable	0.259259	0.000000	0.240000	0.120000	0.071429	0.000000	0.333333	0.148148	0.062500	0.200000	...	0.125000	0.000000	0.000000	0.000000	0.076923	0.076923	0.000000	1.000000	0.240000	0.00
Useful	0.258065	0.038462	0.285714	0.137931	0.111111	0.000000	0.320000	0.333333	0.047619	0.380952	...	0.095238	0.000000	0.200000	0.000000	0.055556	0.055556	0.000000	0.240000	1.000000	0.00
Vague	0.000000	0.200000	0.050000	0.200000	0.000000	0.200000	0.000000	0.000000	0.000000	0.000000	...	0.000000	0.000000	0.125000	0.000000	0.000000	0.000000	0.250000	0.000000	0.000000	1.00

84 rows × 84 columns

sns.clustermap(jaccard_similarity, figsize=(20,20))
plt.show()

import networkx as nx
# requires to install !pip install pygraphviz
# from networkx.drawing.nx_agraph import graphviz_layout

graph_data = {"jaccard": jaccard_similarity, "corr": words_correlation}

@ipywidgets.interact
def plot(similarity=["jaccard", "corr"],
         threshold=np.round(np.arange(0.3, 0.9, 0.05), 2),
         graphviz=False,
        ):
    
    # Transform similarity matrix in a links data frame (3 columns only)
    links = graph_data[similarity].stack().reset_index()
    links.columns = ['word1', 'word2', 'value']
    # Keep only correlation over a threshold and remove self correlation (cor(A,A)=1)
    links_filtered = links.loc[ (links['value'] > threshold) & (links['word1'] != links['word2']) ]
     
    # Build your graph
    G=nx.from_pandas_edgelist(links_filtered, 'word1', 'word2')
    
    # Si instalaste graphiz
    if graphviz: pos = graphviz_layout(G, prog="fdp")
    # Si no tienes instalado
    else: pos = nx.spring_layout(G)
    
    # Plot the network
    plt.figure(figsize=(6 + 15*(1-threshold),6 + 15*(1-threshold)))
    nx.draw(G, with_labels=True, node_color='cornflowerblue', node_size=400*threshold, edge_color='black', 
            linewidths=1, font_size=10 + 10*(1-threshold), pos = pos)
    plt.show()

interactive(children=(Dropdown(description='similarity', options=('jaccard', 'corr'), value='jaccard'), Dropdo…

# define colors
cnames = {
'aliceblue':            '#F0F8FF',
'antiquewhite':         '#FAEBD7',
'aqua':                 '#00FFFF',
'aquamarine':           '#7FFFD4',
'azure':                '#F0FFFF',
'beige':                '#F5F5DC',
'bisque':               '#FFE4C4',
'black':                '#000000',
'blanchedalmond':       '#FFEBCD',
'blue':                 '#0000FF',
'blueviolet':           '#8A2BE2',
'brown':                '#A52A2A',
'burlywood':            '#DEB887',
'cadetblue':            '#5F9EA0',
'chartreuse':           '#7FFF00',
'chocolate':            '#D2691E',
'coral':                '#FF7F50',
'cornflowerblue':       '#6495ED',
'cornsilk':             '#FFF8DC',
'crimson':              '#DC143C',
'cyan':                 '#00FFFF',
'darkblue':             '#00008B',
'darkcyan':             '#008B8B',
'darkgoldenrod':        '#B8860B',
'darkgray':             '#A9A9A9',
'darkgreen':            '#006400',
'darkkhaki':            '#BDB76B',
'darkmagenta':          '#8B008B',
'darkolivegreen':       '#556B2F',
'darkorange':           '#FF8C00',
'darkorchid':           '#9932CC',
'darkred':              '#8B0000',
'darksalmon':           '#E9967A',
'darkseagreen':         '#8FBC8F',
'darkslateblue':        '#483D8B',
'darkslategray':        '#2F4F4F',
'darkturquoise':        '#00CED1',
'darkviolet':           '#9400D3',
'deeppink':             '#FF1493',
'deepskyblue':          '#00BFFF',
'dimgray':              '#696969',
'dodgerblue':           '#1E90FF',
'firebrick':            '#B22222',
'floralwhite':          '#FFFAF0',
'forestgreen':          '#228B22',
'fuchsia':              '#FF00FF',
'gainsboro':            '#DCDCDC',
'ghostwhite':           '#F8F8FF',
'gold':                 '#FFD700',
'goldenrod':            '#DAA520',
'gray':                 '#808080',
'green':                '#008000',
'greenyellow':          '#ADFF2F',
'honeydew':             '#F0FFF0',
'hotpink':              '#FF69B4',
'indianred':            '#CD5C5C',
'indigo':               '#4B0082',
'ivory':                '#FFFFF0',
'khaki':                '#F0E68C',
'lavender':             '#E6E6FA',
'lavenderblush':        '#FFF0F5',
'lawngreen':            '#7CFC00',
'lemonchiffon':         '#FFFACD',
'lightblue':            '#ADD8E6',
'lightcoral':           '#F08080',
'lightcyan':            '#E0FFFF',
'lightgoldenrodyellow': '#FAFAD2',
'lightgreen':           '#90EE90',
'lightgray':            '#D3D3D3',
'lightpink':            '#FFB6C1',
'lightsalmon':          '#FFA07A',
'lightseagreen':        '#20B2AA',
'lightskyblue':         '#87CEFA',
'lightslategray':       '#778899',
'lightsteelblue':       '#B0C4DE',
'lightyellow':          '#FFFFE0',
'lime':                 '#00FF00',
'limegreen':            '#32CD32',
'linen':                '#FAF0E6',
'magenta':              '#FF00FF',
'maroon':               '#800000',
'mediumaquamarine':     '#66CDAA',
'mediumblue':           '#0000CD',
'mediumorchid':         '#BA55D3',
'mediumpurple':         '#9370DB',
'mediumseagreen':       '#3CB371',
'mediumslateblue':      '#7B68EE',
'mediumspringgreen':    '#00FA9A',
'mediumturquoise':      '#48D1CC',
'mediumvioletred':      '#C71585',
'midnightblue':         '#191970',
'mintcream':            '#F5FFFA',
'mistyrose':            '#FFE4E1',
'moccasin':             '#FFE4B5',
'navajowhite':          '#FFDEAD',
'navy':                 '#000080',
'oldlace':              '#FDF5E6',
'olive':                '#808000',
'olivedrab':            '#6B8E23',
'orange':               '#FFA500',
'orangered':            '#FF4500',
'orchid':               '#DA70D6',
'palegoldenrod':        '#EEE8AA',
'palegreen':            '#98FB98',
'paleturquoise':        '#AFEEEE',
'palevioletred':        '#DB7093',
'papayawhip':           '#FFEFD5',
'peachpuff':            '#FFDAB9',
'peru':                 '#CD853F',
'pink':                 '#FFC0CB',
'plum':                 '#DDA0DD',
'powderblue':           '#B0E0E6',
'purple':               '#800080',
'red':                  '#FF0000',
'rosybrown':            '#BC8F8F',
'royalblue':            '#4169E1',
'saddlebrown':          '#8B4513',
'salmon':               '#FA8072',
'sandybrown':           '#FAA460',
'seagreen':             '#2E8B57',
'seashell':             '#FFF5EE',
'sienna':               '#A0522D',
'silver':               '#C0C0C0',
'skyblue':              '#87CEEB',
'slateblue':            '#6A5ACD',
'slategray':            '#708090',
'snow':                 '#FFFAFA',
'springgreen':          '#00FF7F',
'steelblue':            '#4682B4',
'tan':                  '#D2B48C',
'teal':                 '#008080',
'thistle':              '#D8BFD8',
'tomato':               '#FF6347',
'turquoise':            '#40E0D0',
'violet':               '#EE82EE',
'wheat':                '#F5DEB3',
'white':                '#FFFFFF',
'whitesmoke':           '#F5F5F5',
'yellow':               '#FFFF00',
'yellowgreen':          '#9ACD32'}

Tópicos obtenidos usando Jaccard similarity

from IPython.display import display
from networkx.algorithms import community
from netgraph import Graph

np.seterr(invalid='ignore')

@ipywidgets.interact
def plot(similarity=["jaccard", "corr"],
         threshold=np.round(np.arange(0.3, 0.9, 0.05), 2),
         graphviz=False,
        ):

    # Transform correlation matrix in a links data frame (3 columns only)
    links = graph_data[similarity].stack().reset_index()
    links.columns = ['word1', 'word2', 'value']
    
    threshold = 0.3  # remove edges below this weight (similarity)
    
    # Keep only correlation over a threshold and remove self correlation (sim(A,A)=1)
    links_filtered = links.loc[ (links['value'] > threshold) & (links['word1'] != links['word2']) ]
    
    # Build your graph
    G=nx.from_pandas_edgelist(links_filtered, 'word1', 'word2')
        
    communities = community.greedy_modularity_communities(G)
    
    node_groups = []
    for com in communities:
        node_groups.append(list(com))
    
    colors = np.random.choice(list(cnames), len(node_groups), replace=False)
    
    print("Comunidades (tópicos):", len(node_groups))
    
    node_to_community = dict()
    for ci, com in enumerate(communities):
        for node in com:
            node_to_community[node] = ci
            
    node_colors = {node: colors[community_id] for node, community_id in node_to_community.items()}
    
    plt.figure(figsize=(6,6))
    Graph(G,
          node_color=node_colors, node_edge_width=0, edge_alpha=0.1, node_size=1,
          node_layout='community', node_layout_kwargs=dict(node_to_community=node_to_community),
          edge_layout='bundled', edge_layout_kwargs=dict(k=2000),
    )
    plt.show()
    
    display(pd.DataFrame(communities).T)

interactive(children=(Dropdown(description='similarity', options=('jaccard', 'corr'), value='jaccard'), Dropdo…

Tópicos obtenidos usando correlación

similarity = "corr"

# Transform correlation matrix in a links data frame (3 columns only)
links = graph_data[similarity].stack().reset_index()
links.columns = ['word1', 'word2', 'value']

threshold = 0.6  # remove edges below this weight (similarity)

# Keep only correlation over a threshold and remove self correlation (cor(A,A)=1)
links_filtered = links.loc[ (links['value'] > threshold) & (links['word1'] != links['word2']) ]

# Build your graph
G=nx.from_pandas_edgelist(links_filtered, 'word1', 'word2')
    
communities = community.greedy_modularity_communities(G)
 
node_groups = []
for com in communities:
    node_groups.append(list(com))

print("Comunidades (tópicos)", len(node_groups))

colors = np.random.choice(list(cnames), len(node_groups), replace=False)

node_to_community = dict()
for ci, com in enumerate(communities):
    for node in com:
        node_to_community[node] = ci
node_colors = {node: colors[community_id] for node, community_id in node_to_community.items()}

plt.figure(figsize=(6,6))
Graph(G,
      node_color=node_colors, node_edge_width=0, edge_alpha=0.1, node_size=1,
      node_layout='community', node_layout_kwargs=dict(node_to_community=node_to_community),
      edge_layout='bundled', edge_layout_kwargs=dict(k=2000),
)
plt.show()

pd.DataFrame(communities).T

Comunidades (tópicos) 8

/home/salva/anaconda3/lib/python3.9/site-packages/netgraph/_node_layout.py:1549: UserWarning: Graph contains a single community. Unable to compute a community layout. Computing spring layout instead.
  warnings.warn("Graph contains a single community. Unable to compute a community layout. Computing spring layout instead.")

	0	1	2	3	4	5	6	7
0	Bright	Too-technical	Stressful	Energetic	Satisfying	Irrelevant	Old	Unrefined
1	Entertaining	Empowering	Expected	Patronising	Effortless	Contradictory	Unattractive	Unconventional
2	Sophisticated	Motivating	Frustrating	Trustworthy	TimeSaving	None	None	None
3	Unpredictable	Engaging	Fun	Time-consuming	High-quality	None	None	None
4	Intimidating	Reliable	Stimulating	Responsive	None	None	None	None
5	Straightforward	Professional	Dated	Impressive	None	None	None	None
6	Relevant	Exciting	None	None	None	None	None	None
7	SystemOriented	Secure	None	None	None	None	None	None

Visualización de información espacial de usabilidad

Una institución de educación está interesada en mejorar la experiencia de usuario (UX) en su plataforma en línea para aumentar la participación de los estudiantes y mejorar su aprendizaje. Para ello, deciden llevar a cabo un estudio de análisis de datos de UX centrado en el comportamiento de los estudiantes al interactuar con la interfaz de su plataforma educativa.

Una de las métricas clave que desean analizar es la posición espacial del puntero del mouse (coordenadas x, y) mientras los estudiantes navegan por diferentes secciones del curso, acceden a materiales de estudio y participan en actividades de aprendizaje. La institución ha implementado un sistema de seguimiento que registra continuamente las coordenadas x e y del puntero del mouse en relación con los elementos de la interfaz de usuario.

El objetivo principal del análisis de datos es comprender cómo se comportan los estudiantes mientras interactúan con la plataforma en términos de movimientos del mouse. Algunas preguntas de investigación que podrían abordarse incluyen:

1. ¿Cuáles son las áreas de la interfaz de usuario que atraen más la atención de los estudiantes, según la distribución de las coordenadas del mouse?
2. ¿Cómo varía el comportamiento del mouse entre diferentes secciones del curso o tipos de contenido educativo?
3. ¿Existen patrones comunes en los movimientos del mouse antes de que un estudiante realice una acción específica, como acceder a un recurso o participar en un foro de discusión?
4. ¿Hay diferencias en el comportamiento del mouse entre diferentes grupos de estudiantes, como aquellos con diferentes niveles de experiencia académica o áreas de interés?
5. ¿Cómo afectan los cambios en el diseño de la interfaz de usuario a los patrones de comportamiento del mouse y, en última instancia, a la experiencia de aprendizaje del estudiante?

Al analizar los datos de posición del mouse, la institución puede obtener información valiosa sobre cómo los estudiantes interactúan con su plataforma educativa y utilizar estos conocimientos para realizar ajustes en el diseño y la funcionalidad con el objetivo de mejorar la experiencia de aprendizaje y promover el éxito estudiantil.

data = pd.read_csv('https://raw.githubusercontent.com/marsgr6/estadistica-ux/main/data/ux_spatial.csv')

plt.figure(figsize=(16,8))

sns.kdeplot(
    data=data, x="x", y="my", hue='vclass',
    fill=True, common_norm=False, alpha=0.5
)
#a=plt.axis('off')
plt.xlabel('')
plt.ylabel('')
xt=plt.xticks([])
yt=plt.yticks([])
plt.show()

plt.figure(figsize=(8,6))
ax=sns.kdeplot(data=data, x="velocity", hue="vclass", multiple="fill", common_norm=False)
sns.move_legend(ax, "upper left", bbox_to_anchor=(1, 1))
plt.show()

sns.set_context('poster')
plt.figure(figsize=(16,12))
sns.scatterplot(data=data, x='frame', y='id', hue='vclass', s=5, alpha=0.7)
plt.legend(markerscale=1)
plt.show()

sns.set_context('poster')
plt.figure(figsize=(16,12))
sns.scatterplot(data=data, x='x', y='my', hue='vclass', s=5, alpha=0.7)
plt.axis('off');
plt.show()

Análisis de Voronoi

El análisis de Voronoi se puede utilizar para procesar información espacial cuando se tiene un conjunto de puntos distribuidos en un espacio, y se desea dividir ese espacio en regiones basadas en la proximidad a cada punto de datos. Este enfoque es especialmente útil en contextos donde se necesita comprender la relación espacial entre los puntos de datos y su entorno circundante.

Algunos casos comunes donde se puede aplicar el análisis de Voronoi incluyen:

1. Análisis de cobertura de servicio: Por ejemplo, en telecomunicaciones, se puede utilizar el análisis de Voronoi para determinar las áreas de cobertura de diferentes torres de telefonía celular. Cada torre se representa como un punto, y las regiones de Voronoi indican las áreas donde esa torre proporciona una señal más fuerte.

2. Distribución de recursos: En la planificación urbana o la gestión de recursos naturales, el análisis de Voronoi puede utilizarse para dividir un área en regiones que están más cerca de un conjunto de recursos, como hospitales, estaciones de policía o fuentes de agua.

3. Estudio de patrones de movimiento: En aplicaciones de seguimiento de movimiento, como el seguimiento de animales salvajes o el monitoreo del tráfico, el análisis de Voronoi puede utilizarse para dividir el espacio en áreas que están más cerca de puntos de referencia específicos, lo que permite analizar los patrones de movimiento de manera más efectiva.

4. Análisis de ubicaciones de clientes: En el comercio minorista o en la planificación de tiendas, el análisis de Voronoi puede ayudar a determinar las áreas de influencia de diferentes ubicaciones de tiendas, lo que permite tomar decisiones informadas sobre la ubicación de nuevas tiendas o la optimización de la distribución de la cadena de suministro.

En resumen, el análisis de Voronoi es una herramienta poderosa para procesar información espacial en una variedad de contextos donde se necesita comprender la distribución y la relación espacial entre conjuntos de datos.

from scipy.spatial import Voronoi, voronoi_plot_2d
from scipy.spatial import distance
from scipy.interpolate import griddata
from scipy import ndimage

points = np.array(data[['x', 'my']])

vor = Voronoi(points)

fig, ax = plt.subplots(figsize=(16,8))

figv = voronoi_plot_2d(vor, show_vertices=False, line_colors='orange',
                line_width=2, line_alpha=0.6, point_size=2, ax=ax)

plt.xlabel('')
plt.ylabel('')
xt=plt.xticks([])
yt=plt.yticks([])
plt.show()

from scipy.spatial import Voronoi
from shapely.geometry import Polygon

def voronoi_finite_polygons_2d(vor, radius=None):
    """
    Reconstruct infinite voronoi regions in a 2D diagram to finite
    regions.
    Parameters
    ----------
    vor : Voronoi
        Input diagram
    radius : float, optional
        Distance to 'points at infinity'.
    Returns
    -------
    regions : list of tuples
        Indices of vertices in each revised Voronoi regions.
    vertices : list of tuples
        Coordinates for revised Voronoi vertices. Same as coordinates
        of input vertices, with 'points at infinity' appended to the
        end.
    """

    if vor.points.shape[1] != 2:
        raise ValueError("Requires 2D input")

    new_regions = []
    new_vertices = vor.vertices.tolist()

    center = vor.points.mean(axis=0)
    if radius is None:
        radius = vor.points.ptp().max()*2

    # Construct a map containing all ridges for a given point
    all_ridges = {}
    for (p1, p2), (v1, v2) in zip(vor.ridge_points, vor.ridge_vertices):
        all_ridges.setdefault(p1, []).append((p2, v1, v2))
        all_ridges.setdefault(p2, []).append((p1, v1, v2))

    # Reconstruct infinite regions
    for p1, region in enumerate(vor.point_region):
        vertices = vor.regions[region]

        if all(v >= 0 for v in vertices):
            # finite region
            new_regions.append(vertices)
            continue

        # reconstruct a non-finite region
        if p1 in all_ridges:
            ridges = all_ridges[p1]
            new_region = [v for v in vertices if v >= 0]

            for p2, v1, v2 in ridges:
                if v2 < 0:
                    v1, v2 = v2, v1
                if v1 >= 0:
                    # finite ridge: already in the region
                    continue

                # Compute the missing endpoint of an infinite ridge

                t = vor.points[p2] - vor.points[p1] # tangent
                t /= np.linalg.norm(t)
                n = np.array([-t[1], t[0]])  # normal

                midpoint = vor.points[[p1, p2]].mean(axis=0)
                direction = np.sign(np.dot(midpoint - center, n)) * n
                far_point = vor.vertices[v2] + direction * radius

                new_region.append(len(new_vertices))
                new_vertices.append(far_point.tolist())

            # sort region counterclockwise
            vs = np.asarray([new_vertices[v] for v in new_region])
            c = vs.mean(axis=0)
            angles = np.arctan2(vs[:,1] - c[1], vs[:,0] - c[0])
            new_region = np.array(new_region)[np.argsort(angles)]

            # finish
            new_regions.append(new_region.tolist())

    return new_regions, np.asarray(new_vertices)

# make up data points
np.random.seed(1234)
#points = np.random.rand(15, 2)

# compute Voronoi tesselation
vor = Voronoi(points)

plt.figure(figsize=(16,8))

# plot
regions, vertices = voronoi_finite_polygons_2d(vor)

min_x = vor.min_bound[0] - 0.1
max_x = vor.max_bound[0] + 0.1
min_y = vor.min_bound[1] - 0.1
max_y = vor.max_bound[1] + 0.1

mins = np.tile((min_x, min_y), (vertices.shape[0], 1))
bounded_vertices = np.max((vertices, mins), axis=0)
maxs = np.tile((max_x, max_y), (vertices.shape[0], 1))
bounded_vertices = np.min((bounded_vertices, maxs), axis=0)


box = Polygon([[min_x, min_y], [min_x, max_y], [max_x, max_y], [max_x, min_y]])

# colorize
for region in regions:
    polygon = vertices[region]
    # Clipping polygon
    poly = Polygon(polygon)
    poly = poly.intersection(box)
    polygon = [p for p in poly.exterior.coords]

    plt.fill(*zip(*polygon), alpha=0.4)

#plt.plot(points[:, 0], points[:, 1], 'o', color="gray", markersize=1)
plt.axis('equal')
plt.xlim(vor.min_bound[0] - 0.1, vor.max_bound[0] + 0.1)
plt.ylim(vor.min_bound[1] - 0.1, vor.max_bound[1] + 0.1)
a=plt.axis('off')
plt.show()

Gráfico tripcolor

Un gráfico tripcolor es un tipo de visualización tridimensional en la que se colorean los triángulos de una malla en función de un valor asociado a cada uno de ellos. Es especialmente útil para representar datos tridimensionales de manera visual y comprensible.

En un gráfico tripcolor, cada triángulo en la malla se representa como un área coloreada en un plano tridimensional. El color de cada área está determinado por un valor numérico que se asocia a ese triángulo en particular. Este valor puede ser cualquier cosa, como una altura, una temperatura, una densidad, etc.

Los gráficos tripcolor son comúnmente utilizados en disciplinas como la visualización científica, la geografía, la oceanografía, la meteorología y otros campos donde es importante representar datos tridimensionales de manera clara y comprensible. Ayudan a identificar patrones, tendencias y relaciones en los datos de una manera intuitiva y efectiva.

plt.figure(figsize=(16,12))
plt.tripcolor(data.x, data.my, data.velocity)
plt.axis('off');
plt.show()

sns.set_context('poster')
plt.figure(figsize=(16,12))
sns.scatterplot(data=data, x='x', y='my', hue='velocity', size="velocity",
                alpha=0.7, legend=False, sizes=(1, 100),
                palette=sns.color_palette("icefire", as_cmap=True))
plt.axis('off');
plt.show()

Ejemplos adicionales de visualización

• Defina un diccionario de dataframes: Importaremos un conjunto de datasets de ejemplo como un diccionario de dataframes en all_data.

El código a continuación crea un diccionario llamado all_data que contiene múltiples conjuntos de datos cargados desde diversas fuentes utilizando las funciones pd.read_csv de Pandas y sns.load_dataset de Seaborn.

import pandas as pd

all_data = {"Attrition": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/CHR_data.csv"),
            "Usability": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/UX_data.csv"),
            "Tips": sns.load_dataset("tips"),
            "Diamonds": sns.load_dataset("diamonds"),
            "MPG": sns.load_dataset("mpg"),
            "Iris": sns.load_dataset("iris"),
            "Geyser": sns.load_dataset("geyser"),
            "Penguins": sns.load_dataset("penguins"),
            "Titanic": sns.load_dataset("titanic")
           }

• Carga de Conjuntos de Datos desde CSV (pd.read_csv): Algunos conjuntos de datos, como "Attrition" y "Usability", se cargan desde archivos CSV ubicados en GitHub utilizando la función pd.read_csv de Pandas. Estos conjuntos de datos probablemente contienen información relacionada con la rotación de empleados ("Attrition") y la usabilidad de algún producto o servicio ("Usability").

• Carga de Conjuntos de Datos Seaborn (sns.load_dataset): Otros conjuntos de datos, como "Tips", "MPG", "Iris", "Geyser", "Penguins" y "Titanic", se cargan utilizando la función sns.load_dataset de Seaborn. Estos conjuntos de datos son ejemplos de conjuntos de datos incorporados en la biblioteca Seaborn y suelen utilizarse para fines educativos y demostrativos en visualización de datos y análisis exploratorio.

• Para acceder a un conjunto de datos use: all_data[clave] donde clave es el nombre del dataset, ej.: all_data["Usability"].

En resumen, el diccionario all_data contiene múltiples conjuntos de datos que se utilizan para ejemplificar y practicar técnicas de análisis de datos y visualización. Cada clave del diccionario corresponde a un conjunto de datos específico, y los conjuntos de datos pueden tener diferentes formatos y tipos de información.

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import warnings
%matplotlib inline

warnings.filterwarnings('ignore')

all_data = {"Attrition": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/CHR_data.csv"),
            "Usability": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/UX_data.csv"),
            "Tips": sns.load_dataset("tips"),
            "Diamonds": sns.load_dataset("diamonds"),
            "MPG": sns.load_dataset("mpg"),
            "Iris": sns.load_dataset("iris"),
            "Geyser": sns.load_dataset("geyser"),
            "Penguins": sns.load_dataset("penguins"),
            "Titanic": sns.load_dataset("titanic")
           }

sns.get_dataset_names()

['anagrams',
 'anscombe',
 'attention',
 'brain_networks',
 'car_crashes',
 'diamonds',
 'dots',
 'dowjones',
 'exercise',
 'flights',
 'fmri',
 'geyser',
 'glue',
 'healthexp',
 'iris',
 'mpg',
 'penguins',
 'planets',
 'seaice',
 'taxis',
 'tips',
 'titanic']

all_data["Iris"].head()

	sepal_length	sepal_width	petal_length	petal_width	species
0	5.1	3.5	1.4	0.2	setosa
1	4.9	3.0	1.4	0.2	setosa
2	4.7	3.2	1.3	0.2	setosa
3	4.6	3.1	1.5	0.2	setosa
4	5.0	3.6	1.4	0.2	setosa

Un diagrama de caja, también conocido como boxplot o gráfico de caja y bigotes, es una representación visual de la distribución estadística de un conjunto de datos. Este tipo de gráfico proporciona información sobre la tendencia central, la dispersión y la presencia de valores atípicos en los datos.

Aquí están los componentes clave de un diagrama de caja:

Caja (Box): La caja representa el rango intercuartil (IQR, por sus siglas en inglés), que abarca desde el primer cuartil (Q1) hasta el tercer cuartil (Q3). La altura de la caja indica la variabilidad dentro del rango intercuartil.

Línea Mediana (Mediana): Dentro de la caja, se dibuja una línea que representa la mediana (o segundo cuartil, Q2). La mediana es el valor que divide el conjunto de datos en dos partes iguales.

Bigotes (Whiskers): Los bigotes se extienden desde la caja hasta los valores extremos. En los diagramas de caja estándar, los bigotes suelen extenderse hasta 1.5 veces el IQR desde Q1 y Q3. Puntos más allá de los bigotes se consideran valores atípicos.

Valores Atípicos (Outliers): Puntos individuales que se encuentran más allá de los bigotes se representan como puntos o asteriscos y se consideran valores atípicos.

El diagrama de caja es una herramienta eficaz para visualizar la distribución de los datos, especialmente cuando se comparan múltiples conjuntos de datos. Permite identificar la presencia de sesgo, la concentración de datos alrededor de la mediana y la existencia de valores atípicos. Este tipo de gráfico es ampliamente utilizado en estadísticas descriptivas y exploratorias.

Aquí, sns.boxplot es una función de Seaborn utilizada para crear un gráfico de caja. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico. En este caso, parece que all_data["Penguins"] es el DataFrame específico que contiene los datos relacionados con pingüinos.

• all_data: es un diccionario de dataframes.
• "Penguins": es el dataframe a selccionar.

x: La variable que se representará en el eje x. En este caso, parece que "species" se usará para agrupar los datos en el eje x.

y: La variable que se representará en el eje y. En este caso, parece que "bill_length_mm" se utilizará para la altura del gráfico de caja.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías. En este caso, "species" se utilizará para diferenciar colores entre las especies de pingüinos.

palette: Una paleta de colores que se utilizará para colorear las diferentes categorías. La variable palette debe estar definida previamente en tu código y se utiliza para personalizar la apariencia del gráfico.

Esta línea de código crea un gráfico de caja utilizando Seaborn, donde los datos se agrupan por especie de pingüino en el eje x, la longitud del pico se representa en el eje y, y los colores se utilizan para diferenciar las especies.

sns.reset_defaults()
palette = sns.color_palette("Set2", 12)  # If you have more than 12 categories change this
sns.boxplot(data=all_data["Penguins"], x="species", y="bill_length_mm", hue="species", palette=palette)
plt.show();

Gráfico de caja ampliada (boxenplot) basado en el DataFrame all_data["Penguins"].

sns.boxenplot es una función de Seaborn utilizada para crear un gráfico de caja ampliada. Los argumentos de esta función son similares a los de sns.boxplot:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x: La variable que se representará en el eje x.

y: La variable que se representará en el eje y.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

palette: Una paleta de colores que se utilizará para colorear las diferentes categorías.

El gráfico de caja ampliada (boxenplot) es similar al gráfico de caja (boxplot), pero proporciona más detalles sobre la distribución de los datos, especialmente en las colas de la distribución.

El código crea un gráfico de caja ampliada utilizando Seaborn, donde los datos se agrupan por especie de pingüino en el eje x, la longitud del pico se representa en el eje y, y los colores se utilizan para diferenciar las especies.

sns.reset_defaults()
palette = sns.color_palette("Set2", 12)  # If you have more than 12 categories change this
sns.boxenplot(data=all_data["Penguins"], x="species", y="bill_length_mm", hue="species", palette=palette)
plt.show();

Un gráfico de violin es el matrimonio entre un diagrama de cajas y un gráfico de densidad.

Un gráfico de violín es un tipo de visualización estadística que combina elementos de un gráfico de caja (boxplot) y un gráfico de densidad de kernel. Este tipo de gráfico se utiliza para representar la distribución de un conjunto de datos y proporciona información sobre su forma y densidad.

En un gráfico de violín, cada violín representa una variable o una categoría, y la anchura del violín en un punto dado muestra la densidad de datos en esa ubicación.

El gráfico de violín es útil cuando se desea visualizar la distribución de datos de manera más detallada que la proporcionada por un simple boxplot. Puede ser especialmente efectivo para comparar múltiples distribuciones y entender la variabilidad en diferentes categorías o grupos.

sns.violinplot es una función de Seaborn utilizada para crear un gráfico de violín. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x: La variable que se representará en el eje x. En este caso, "Department" parece ser la variable que agrupará los datos.

y: La variable que se representará en el eje y. En este caso, "Age" parece ser la variable numérica que se mostrará en el gráfico.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

split: Un parámetro booleano que determina si los violines se dividen por el valor de hue.

common_norm: Un parámetro booleano que normaliza los violines de manera uniforme si es True.

cut: Un valor que determina la extensión de los violines.

palette: Una paleta de colores que se utilizará para colorear las diferentes categorías.

inner: Un parámetro que especifica el estilo de representación interna en el gráfico de violín. En este caso, "stick" indica que se mostrarán puntos internos.

La línea de código crea un gráfico de violín utilizando Seaborn, donde los datos se agrupan por departamento en el eje x, la edad se representa en el eje y, y se utiliza el atributo "Attrition" para diferenciar colores y visualizar la relación con la rotación del personal ("Attrition").

sns.reset_defaults()
sns.violinplot(data=all_data["Attrition"], x="Department", y="Age", hue="Attrition", split=True,
               common_norm=False, cut=0, palette=palette, inner="stick")
plt.show();

Un lineplot es un tipo de gráfico utilizado para visualizar la relación entre dos variables continuas a lo largo de un eje cartesiano bidimensional, donde generalmente una variable se representa en el eje x y la otra en el eje y. Este tipo de gráfico conecta los puntos de datos con líneas, lo que facilita la identificación de patrones y tendencias a lo largo de la variable independiente.

Algunas características clave de un lineplot son:

Conexión de Puntos: Los puntos de datos se conectan con líneas, lo que permite observar la evolución o cambio en las variables a medida que se mueven a lo largo del eje x.

Tendencias: Los lineplots son útiles para identificar tendencias generales en los datos. Por ejemplo, si los puntos tienden a subir o bajar de izquierda a derecha, esto sugiere una tendencia positiva o negativa.

Variabilidad: La variabilidad en los datos se puede visualizar observando la dispersión de las líneas alrededor de la tendencia central.

Múltiples Líneas: Puedes representar múltiples líneas en un solo gráfico para comparar las tendencias entre diferentes categorías o grupos.

Seaborn y otras bibliotecas de visualización de datos en Python proporcionan funciones específicas para crear lineplots. Estos gráficos son útiles en diversas situaciones, como analizar series temporales, comparar cambios en variables a lo largo de diferentes categorías o explorar relaciones entre dos variables continuas.

sns.lineplot es una función de Seaborn utilizada para crear un gráfico de líneas. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x: La variable que se representará en el eje x.

y: La variable que se representará en el eje y.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

err_style: Un parámetro que especifica el estilo de representación de las barras de error.

ci: Un parámetro que establece el nivel de confianza para las barras de error.

estimator: Un parámetro que determina cómo se calculan los valores para el gráfico de líneas. En este caso, 'mean' indica que se utilizará la media.

palette: Una paleta de colores que se utilizará para colorear las diferentes categorías.

La línea de código crea un gráfico de líneas utilizando Seaborn, donde los datos se agrupan por departamento en el eje x, la edad se representa en el eje y, y los colores se utilizan para diferenciar las categorías de rotación de personal ("Attrition"). Las barras de error se muestran con un estilo de "bars" y se calculan basándose en la media con un nivel de confianza del 68%.

sns.reset_defaults()
sns.lineplot(data=all_data["Attrition"], x="Department", y="Age", hue="Attrition",
             err_style="bars", ci=68, estimator='mean', palette=palette)
plt.show()

Un histplot es un tipo de gráfico de histograma proporcionado por la biblioteca Seaborn en Python. Este gráfico es utilizado para visualizar la distribución de un conjunto de datos en términos de frecuencia o densidad de probabilidad de las observaciones en diferentes intervalos (bins).

Características clave de un histplot en Seaborn:

Frecuencia o Densidad: Puedes elegir visualizar la frecuencia absoluta de las observaciones en cada bin o la densidad de probabilidad (normalizada).

Múltiples Distribuciones: Puedes superponer múltiples distribuciones en el mismo gráfico para compararlas. En el caso de datos categóricos adicionales (por ejemplo, utilizando el parámetro hue), puedes diferenciar las distribuciones por colores.

Elementos de Gráfico: Seaborn permite personalizar el tipo de elemento de gráfico utilizado en el histograma. Por ejemplo, puedes usar barras, líneas de escalón, polígonos, etc.

Normalización: Puedes optar por normalizar las distribuciones para que la suma de las áreas de los bins sea igual a 1 (opción common_norm).

sns.histplot es una función de Seaborn utilizada para crear un gráfico de histograma. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x: La variable que se representará en el eje x.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

stat: Un parámetro que especifica la estadística que se visualizará en el histograma. En este caso, "density" indica que se visualizará la densidad de probabilidad.

multiple: Un parámetro que determina cómo se muestran las múltiples distribuciones. "layer" indica que se deben superponer.

element: Un parámetro que especifica el tipo de elemento a dibujar en el gráfico. "step" indica que se deben utilizar líneas de escalón.

common_norm: Un parámetro booleano que normaliza las densidades de las diferentes categorías (sumen 1) si es True.

La línea de código crea un gráfico de histograma utilizando Seaborn, donde los datos se representan en el eje x por la anchura de los pétalos ("petal_width"), y las diferentes especies de iris se diferencian por colores. La opción "step" indica que se deben utilizar líneas de escalón en lugar de barras continuas.

sns.reset_defaults()
sns.histplot(data=all_data["Iris"], x="petal_width", hue="species", stat="density",
                          multiple="layer", element="step", common_norm=False)
plt.show()

Un kdeplot (Kernel Density Estimate plot) es un tipo de gráfico que visualiza la distribución de un conjunto de datos mediante la estimación de la función de densidad de probabilidad. En lugar de utilizar barras como en un histograma, el kdeplot utiliza curvas suavizadas para representar la distribución.

Algunas características clave de un kdeplot son:

Densidad de Probabilidad: Muestra la distribución de probabilidad de los datos. Cada curva representa una estimación de la función de densidad de probabilidad.

Suavizado: La suavización se logra mediante el uso de un núcleo (kernel) para cada punto de datos. Estos núcleos se suman para formar la curva suavizada.

sns.kdeplot es una función de Seaborn utilizada para crear un gráfico de densidad de kernel. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x: La variable que se representará en el eje x.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

multiple: Un parámetro que determina cómo se muestran las múltiples distribuciones. "layer" indica que se deben superponer.

fill: Un parámetro booleano que determina si se deben llenar las áreas bajo las curvas de densidad.

cut: Un valor que controla hasta dónde se extiende la estimación de densidad.

common_norm: Un parámetro booleano que normaliza las densidades de las diferentes categorías de manera uniforme si es True.

La línea de código crea un gráfico de densidad de kernel utilizando Seaborn, donde los datos se representan en el eje x por la anchura de los pétalos ("petal_width"), y las diferentes especies de iris se diferencian por colores. Las curvas de densidad se superponen y las áreas bajo las curvas están llenas.

sns.reset_defaults()
sns.kdeplot(data=all_data["Iris"], x="petal_width", hue="species",
                          multiple="layer", fill=True, cut=0, common_norm=False)
plt.show()

Podemos extender el kdeplot a 2 dimensiones

sns.displot es una función de Seaborn utilizada para crear un gráfico de dispersión bidimensional con estimaciones de densidad de kernel. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x y y: Las variables que se representarán en los ejes x e y, respectivamente.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

common_norm: Un parámetro booleano que normaliza las densidades de las diferentes categorías de manera uniforme si es True.

kind: Un parámetro que especifica el tipo de gráfico. En este caso, "kde" indica que se utilizarán estimaciones de densidad de kernel.

La línea de código crea un gráfico de dispersión bidimensional con KDE utilizando Seaborn, donde los datos se dispersan en el espacio bidimensional definido por las variables "petal_width" y "petal_length", y las diferentes especies de iris se diferencian por colores. Las áreas de mayor densidad están resaltadas por las estimaciones de densidad de kernel.

sns.reset_defaults()
sns.displot(data=all_data["Iris"],
            x="petal_width", y="petal_length", hue="species",
            common_norm=False, kind="kde")
plt.show()

Un scatterplot es un tipo de gráfico que representa datos en un plano cartesiano bidimensional, donde cada punto en el gráfico representa la intersección de dos variables. Es una forma efectiva de visualizar la relación entre dos variables cuantitativas.

Características clave de un scatterplot:

Variables en los Ejes: Un scatterplot tiene dos ejes, el eje x y el eje y, que representan dos variables diferentes.

Puntos de Datos: Cada punto en el gráfico representa una observación o entrada en tus datos, y su posición en el plano es determinada por los valores de las dos variables.

Relación Visual: La disposición y distribución de los puntos en el gráfico proporciona información visual sobre la relación entre las dos variables. Puedes observar patrones, tendencias, dispersión, y posiblemente identificar correlaciones o patrones no lineales.

Múltiples Variables: Aunque un scatterplot tradicional muestra la relación entre dos variables, existen variaciones, como el scatterplot tridimensional (3D), que permiten representar tres variables al incluir un tercer eje.

En general, un scatterplot es una herramienta poderosa para explorar la relación entre dos variables cuantitativas. La clave es interpretar visualmente cómo cambian los puntos en el gráfico a medida que las variables cambian sus valores.

Si deseas representar más de dos variables, puedes explorar opciones como utilizar colores (mediante el parámetro hue), tamaños (mediante el parámetro size), o incluso formas distintas para representar categorías adicionales. Sin embargo, cada punto en el gráfico seguirá estando definido por las dos variables en los ejes x e y.

sns.scatterplot es una función de Seaborn utilizada para crear un gráfico de dispersión bidimensional. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x y y: Las variables que se representarán en los ejes x e y, respectivamente.

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías (puede ser numérica o categórica).

size: Una variable que se utilizará para determinar el tamaño de los puntos en el gráfico.

La línea de código crea un gráfico de dispersión bidimensional utilizando Seaborn, donde los datos se dispersan en el espacio bidimensional definido por las variables "bill_length_mm" y "bill_depth_mm". Los puntos se diferencian por colores según la especie de pingüino y el tamaño de los puntos está determinado por la masa corporal ("body_mass_g").

sns.reset_defaults()
sns.scatterplot(data=all_data["Penguins"],
                x="bill_length_mm", y="bill_depth_mm", hue="species", #style="species",
                size="body_mass_g")
plt.show()

Un gráfico categórcio (catplot) es una función de la biblioteca Seaborn en Python que se utiliza para crear gráficos categóricos. Puede representar relaciones categóricas en datos utilizando varios tipos de gráficos, como diagramas de dispersión categóricos, gráficos de barras, gráficos de violín, gráficos de cajas y más. catplot se diseñó para ser una interfaz general para gráficos categóricos y puede adaptarse a diferentes tipos de visualizaciones según la naturaleza de los datos y la relación que deseas explorar.

Características clave de catplot:

Tipos de Gráficos: Puede generar varios tipos de gráficos categóricos utilizando el parámetro kind, como "strip" (diagrama de dispersión categórico), "bar" (gráfico de barras), "box" (gráfico de cajas), "violin" (gráfico de violín), entre otros.

Variables Categóricas: Puedes dividir los datos en subgrupos utilizando variables categóricas con los parámetros hue, col, y row.

Múltiples Variables: catplot permite explorar relaciones entre múltiples variables categóricas y cuantitativas.

Facetado: Puedes crear gráficos facetados (divididos en subgráficos) utilizando los parámetros col y row.

Estadísticas Resumidas: Puedes agregar estadísticas resumidas, como medias, medianas, etc., a través del parámetro estimator.

Customización: catplot ofrece una variedad de opciones de personalización para adaptarse a tus necesidades específicas.

sns.catplot es una función de Seaborn utilizada para crear gráficos categóricos. Los argumentos de esta función son:

data: El DataFrame que contiene los datos que se utilizarán para el gráfico.

x y y: Las variables que se representarán en los ejes x e y, respectivamente.

col: Una variable categórica que se utilizará para dividir los datos en columnas separadas (subgráficos).

hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.

kind: Un parámetro que especifica el tipo de gráfico. En este caso, "swarm" indica que se debe utilizar un gráfico de enjambre.

La línea de código crea un gráfico de enjambre utilizando Seaborn, donde los datos se representan en el eje x por la longitud del pico ("bill_length_mm"), y se crea un gráfico separado para cada isla (col="island"). Los puntos en el gráfico se diferencian por especie ("species") y color según el género ("sex"). Un gráfico de enjambre muestra puntos individuales, evitando la superposición tanto como sea posible para resaltar la distribución de los datos.

sns.catplot(data=all_data["Penguins"], x="bill_length_mm", y="species",
            col="island", hue="sex", kind="swarm");
plt.show()

Heatmaps

Podemos crear un gráfico de mapa de calor (heatmap) para un análisis bivariado de variables categóricas, a partir de la tabla de contigencia de dichas variables.

• Creación del DataFrame: Se crea un DataFrame llamado df_2dhist utilizando un bucle de comprensión ({... for ...}) que cuenta las ocurrencias de cada valor en la columna 'NUI' para cada categoría en la columna 'Kinect'. El DataFrame resultante tiene 'Kinect' en el índice y los valores únicos de 'NUI' como columnas.

• Creación del Mapa de Calor: Se utiliza sns.heatmap para crear un mapa de calor basado en el DataFrame df_2dhist. El parámetro cmap=... especifica el esquema de color (en este caso, 'Spectral_r'), y annot=True agrega etiquetas con los valores en cada celda del mapa de calor.

El código visualiza la distribución de las ocurrencias de valores en la columna 'NUI' para cada categoría en la columna 'Kinect' utilizando un mapa de calor. La intensidad del color en el mapa de calor indica la cantidad de ocurrencias en cada combinación de categorías.

df_2dhist = pd.DataFrame({
    x_label: grp['NUI'].value_counts()
    for x_label, grp in all_data['Usability'].groupby('Kinect')
})
sns.heatmap(df_2dhist, cmap='viridis', annot=True, cbar=False)
plt.xlabel('Kinect')
_ = plt.ylabel('NUI')
plt.show()

Heatmap de una matriz de correlación

corr_matrix = all_data["MPG"].corr(): calcula la matriz de correlación para el dataframe "MPG" en el diccionario de datos "all_data". La función corr() de pandas calcula la correlación entre las columnas de un DataFrame. En este caso, se está calculando la matriz correlación de de todas las variables en el conjunto de datos.

sns.clustermap(corr_matrix, annot=True): crea un clustermap de la matriz de correlación. Un clustermap es una visualización de la matriz de correlación que también incluye un dendrograma de agrupamiento en filas y columnas. Cada celda del clustermap representa la correlación entre dos variables. El parámetro annot=True agrega etiquetas de valores numéricos en cada celda del mapa para indicar la magnitud de la correlación.

En resumen, este código ayuda a visualizar la estructura de correlación entre las variables en el conjunto de datos, destacando patrones y relaciones entre las variables mediante el uso de un clustermap.

corr_matrix = all_data["MPG"].select_dtypes(include = 'number').corr()
sns.clustermap(corr_matrix, annot=True)
plt.show()

Heatmap de un dataframe

La función clustermap de Seaborn puede utilizarse para visualizar patrones en un DataFrame, no solo en una matriz específica.

Podemos construir un heatmap de un dataframe, en este caso se visualiza la relación entre las variables y además entre observaciones. Es decir se construye un dendrograma por columnas y por filas en el dataset.

• Código para usar clustermap con un dataframe:

sns.clustermap(df, annot=True)

• DataFrame de Entrada (df): La función clustermap toma como entrada un DataFrame. En este caso, se utiliza df.corr() para calcular la matriz de correlación entre las columnas del DataFrame. Puedes personalizar esta parte según el tipo de análisis que desees realizar.

• Annotación (annot=True): El parámetro annot se utiliza para agregar etiquetas de valores en cada celda del clustermap. Si annot está establecido en True, se mostrarán los valores numéricos en las celdas.

• Esquema de Colores (cmap="coolwarm"): El parámetro cmap permite seleccionar el esquema de colores que se utilizará en el clustermap. En este caso, se ha seleccionado el esquema de colores "coolwarm", pero puedes elegir otros esquemas de colores según tus preferencias.

• Tamaño de la Figura (figsize=(10, 8)): El parámetro figsize permite controlar el tamaño de la figura que se genera. Puedes ajustar estos valores según tus necesidades para obtener una visualización más grande o más pequeña.

La visualización resultante será un clustermap que muestra la matriz de correlación entre las variables del DataFrame, con dendrogramas que indican la agrupación jerárquica de las variables en filas y columnas. Este enfoque es útil para explorar patrones y relaciones en un conjunto de datos completo.

• En particular en el ejemplo a continuación,
  • se realiza un muestreo del dataframe: .sample(n=60, random_state=1),
  • se elimina la variable price: .drop(columns='price'),
  • se eliminan valores faltantes: .dropna(),
  • se seleccionan solo las variables numéricas: .select_dtypes(include = 'number').

sns.clustermap(all_data["Diamonds"].select_dtypes(
    include = 'number').dropna().sample(
    n=60, random_state=1).drop(columns='price'),
               annot=True)

Puede usar los siguientes parámetros adicionales para clustermap:

• metric: por defecto euclidean.
• z_score: int o None, opcional. Ya sea 0 (filas) o 1 (columnas). Indica si calcular o no los z-scores para las filas o las columnas. Los z-scores se calculan mediante la fórmula z = (x - media) / std, por lo que los valores en cada fila (columna) tendrán restada la media de la fila (columna), y luego se dividirán por la desviación estándar de la fila (columna). Esto asegura que cada fila (columna) tenga una media de 0 y una varianza de 1.
• standard_scale: int o None, opcional. Ya sea 0 (filas) o 1 (columnas). Indica si estandarizar o no esa dimensión, lo que significa que para cada fila o columna, se restará el mínimo y se dividirá cada elemento por su máximo.

sns.clustermap(all_data["Diamonds"].select_dtypes(
    include = 'number').dropna().sample(
    n=60, random_state=1), z_score=1,
               annot=True)
plt.show()

Pairplot

La función sns.pairplot de la biblioteca Seaborn se utiliza para crear una matriz de gráficos de dispersión para visualizar las relaciones bivariadas en un conjunto de datos. Cuando se aplica a un conjunto de datos específico, como all_data["Penguins"], y se utiliza el argumento hue="species", se está creando una matriz de gráficos de dispersión que destaca las relaciones entre las variables del conjunto de datos para cada especie de pingüino.

Aquí está el significado de los parámetros utilizados:

all_data["Penguins"]: Se refiere al conjunto de datos específico que contiene información sobre los pingüinos.

hue="species": Divide los datos según la variable "species" (especie de pingüino) y utiliza colores diferentes para representar cada especie en los gráficos de dispersión.

diag_kind="kde": Especifica el tipo de gráfico diagonal que se mostrará en la matriz. En este caso, se utiliza "kde", que significa "kernel density estimate" o "estimación de densidad de kernel". En lugar de mostrar un histograma en la diagonal, se representa la distribución de cada variable como una función de densidad de kernel.

En resumen, sns.pairplot(all_data["Penguins"], hue="species", diag_kind="kde") crea una matriz de gráficos de dispersión para explorar las relaciones entre las variables del conjunto de datos de pingüinos, destacando las diferencias entre las especies mediante el uso de colores y mostrando estimaciones de densidad de kernel en la diagonal. Esta visualización es útil para identificar patrones y relaciones en los datos.

sns.pairplot(all_data["Penguins"], hue="species", diag_kind="kde")
plt.show()

Visualización de valores faltantes

La biblioteca missingno, que se ha importado con el alias msno se utiliza para visualizar la presencia y ausencia de valores faltantes en un DataFrame.

Matriz de Valores Faltantes (msno.matrix(df)): La función matrix de missingno toma un DataFrame como entrada y crea una matriz de valores faltantes. En esta matriz, cada columna representa una columna del DataFrame y cada fila representa una entrada (observación). Las celdas en blanco indican valores presentes, mientras que las celdas con líneas diagonales indican valores faltantes.

Las barras a la derecha de la matriz muestran la cantidad de valores faltantes en cada columna. La barra inferior muestra la cantidad de valores faltantes en cada fila. Esta visualización proporciona una visión general rápida de la distribución de los valores faltantes en todo el conjunto de datos.

Ejemplo de interpretación:

Si ves una columna con muchas líneas (celdas) en blanco significa que esa columna tiene muchos valores faltantes. Si ves filas con muchas líneas en blanco, significa que esas filas tienen varios valores faltantes. La función matrix de missingno es útil para identificar patrones y concentraciones de valores faltantes en un DataFrame, lo que puede ayudar en la toma de decisiones sobre cómo manejar esos valores faltantes.

# la librería missingno nos permite visualizar valores faltantes
import missingno as msno

# Add dataframe to dictionary
all_data["NY_collision"] = pd.read_csv("https://raw.githubusercontent.com/ResidentMario/missingno-data/master/nyc_collision_factors.csv")

msno.matrix(all_data["NY_collision"])
plt.show()

Gráfico de Barras de Valores Faltantes (msno.bar(df)): La función bar toma un DataFrame como entrada y crea un gráfico de barras que muestra la proporción de valores faltantes en cada columna.

Cada barra representa una columna del DataFrame. La altura de la barra indica la proporción de valores faltantes en esa columna. Cuanto más alta sea la barra, más valores faltantes hay en esa columna. Este gráfico es útil para tener una visión general rápida de las columnas que tienen muchos valores faltantes en comparación con las que tienen pocos o ninguno. Puede ayudarte a identificar las características del conjunto de datos que pueden requerir atención en términos de manejo de valores faltantes.

Ejemplo de interpretación:

Si ves una barra alta, significa que la columna correspondiente tiene una proporción significativa de valores faltantes. Si ves una barra baja, significa que la columna tiene pocos o ningún valor faltante.

msno.bar(all_data["NY_collision"])
plt.show()

Mapa de Calor de la Correlación de Valores Faltantes (msno.heatmap(df)): La función heatmap toma un DataFrame como entrada y crea un mapa de calor que muestra la correlación entre las ausencias de datos en diferentes columnas.

La escala de colores indica el grado de correlación. Cuanto más oscuro es el color, mayor es la correlación de ausencias entre las columnas. Un color más claro indica una baja correlación de ausencias entre las columnas. Este mapa de calor es útil para identificar patrones de ausencias de datos. Si dos columnas tienen valores faltantes que tienden a ocurrir juntos, la correlación será alta, y eso se reflejará en áreas más oscuras en el mapa de calor.

Ejemplo de interpretación:

Áreas más oscuras en el mapa de calor indican una mayor correlación de ausencias entre las columnas. Áreas más claras indican una correlación más baja de ausencias entre las columnas.

msno.heatmap(all_data["NY_collision"])
plt.show()

Dendrograma de Agrupamiento Jerárquico (msno.dendrogram(df)): La función dendrogram toma un DataFrame como entrada y crea un dendrograma que muestra cómo las columnas se agrupan jerárquicamente en función de la correlación de ausencias de datos.

Las líneas en el dendrograma conectan las columnas y la longitud de las líneas representa la distancia (o disimilitud) entre las columnas. Las conexiones más largas indican una mayor disimilitud entre las ausencias de datos en las columnas conectadas. La altura en el dendrograma indica cuán lejos se encuentran las columnas. Las columnas que están agrupadas en niveles más bajos tienen una mayor correlación de ausencias de datos entre sí. Este dendrograma es útil para identificar grupos de columnas que tienen patrones de ausencia de datos similares. Las columnas que están más cercanas en el dendrograma tienden a tener patrones de ausencia de datos más similares entre sí.

Ejemplo de interpretación:

Las columnas que están agrupadas en niveles más bajos en el dendrograma tienen patrones de ausencia de datos más similares entre sí. Las conexiones más largas en el dendrograma indican una mayor disimilitud entre las ausencias de datos en las columnas conectadas.

msno.dendrogram(all_data["NY_collision"])
plt.show()

Datos jerárquicos

Los datos jerárquicos son aquellos que están organizados en una estructura de tipo árbol o jerarquía, donde los elementos se agrupan en niveles y existen relaciones de subordinación entre ellos. Esta estructura es común en diversos contextos, como organizaciones empresariales, sistemas de archivos, taxonomías biológicas y otros.

Un ejemplo común de datos jerárquicos es la estructura de carpetas y archivos en un sistema de archivos de computadora. En esta estructura, hay carpetas principales (o directorios) que contienen subcarpetas y archivos, y estas subcarpetas pueden contener a su vez más subcarpetas y archivos. La relación jerárquica se representa visualmente como una estructura de árbol.

La visualización de datos jerárquicos suele realizarse utilizando diagramas de árbol o dendrogramas. Estos gráficos representan las relaciones jerárquicas entre los elementos mediante nodos y conexiones. Cada nodo en el diagrama representa un elemento y las conexiones entre los nodos indican las relaciones jerárquicas. Los nodos que están conectados directamente a un nodo principal se consideran subordinados a ese nodo.

Ejemplos de visualización de datos jerárquicos incluyen:

• Diagramas de árbol: Representan la jerarquía mediante ramas y nodos conectados.

• Dendrogramas: Son gráficos de árbol utilizados en análisis de clúster para representar relaciones de agrupación.

• Estructuras organizativas: Representan la jerarquía en una organización empresarial.

Estas visualizaciones permiten comprender la estructura jerárquica y las relaciones entre los elementos de manera intuitiva.

La visualización de datos jerárquicos puede incluir dos tipos de gráficos específicos:

• Sankey Diagrams (Diagramas de Sankey): Estos gráficos son especialmente útiles para visualizar flujos y relaciones entre distintas categorías jerárquicas. En un Sankey Diagram, las flechas representan el flujo de cantidades entre nodos, y el ancho de las flechas se ajusta proporcionalmente a la cantidad de flujo. Son efectivos para mostrar cómo se distribuyen o transfieren recursos, información o cantidades entre diferentes niveles de jerarquía.

• Treemaps (Mapas de Árbol): Los Treemaps son visualizaciones que utilizan rectángulos anidados para representar la jerarquía de datos. Cada rectángulo representa un nodo en la jerarquía, y su tamaño corresponde a alguna medida específica, como el valor numérico asociado al nodo. Los nodos secundarios se pueden colocar dentro de los nodos principales, creando una representación visual intuitiva de la jerarquía.

• Incorporar estos gráficos puede enriquecer la comprensión de la estructura jerárquica y las relaciones dentro de los conjuntos de datos.

En este notebook puede ver un ejemplo de gráficos para datos jerárquicos.

Script de visualización

• Defina un diccionario de dataframes: Importaremos un conjunto de datasets de ejemplo como un diccionario de dataframes en all_data.

El código a continuación crea un diccionario llamado all_data que contiene múltiples conjuntos de datos cargados desde diversas fuentes utilizando las funciones pd.read_csv de Pandas y sns.load_dataset de Seaborn.

import pandas as pd

all_data = {"Attrition": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/CHR_data.csv"),
            "Usability": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/UX_data.csv"),
            "Tips": sns.load_dataset("tips"),
            "Diamonds": sns.load_dataset("diamonds"),
            "MPG": sns.load_dataset("mpg"),
            "Iris": sns.load_dataset("iris"),
            "Geyser": sns.load_dataset("geyser"),
            "Penguins": sns.load_dataset("penguins"),
            "Titanic": sns.load_dataset("titanic")
           }

• Carga de Conjuntos de Datos desde CSV (pd.read_csv): Algunos conjuntos de datos, como "Attrition" y "Usability", se cargan desde archivos CSV ubicados en GitHub utilizando la función pd.read_csv de Pandas. Estos conjuntos de datos probablemente contienen información relacionada con la rotación de empleados ("Attrition") y la usabilidad de algún producto o servicio ("Usability").

• Carga de Conjuntos de Datos Seaborn (sns.load_dataset): Otros conjuntos de datos, como "Tips", "MPG", "Iris", "Geyser", "Penguins" y "Titanic", se cargan utilizando la función sns.load_dataset de Seaborn. Estos conjuntos de datos son ejemplos de conjuntos de datos incorporados en la biblioteca Seaborn y suelen utilizarse para fines educativos y demostrativos en visualización de datos y análisis exploratorio.

• Para acceder a un conjunto de datos use: all_data[clave] donde clave es el nombre del dataset, ej.: all_data["Usability"].

En resumen, el diccionario all_data contiene múltiples conjuntos de datos que se utilizan para ejemplificar y practicar técnicas de análisis de datos y visualización. Cada clave del diccionario corresponde a un conjunto de datos específico, y los conjuntos de datos pueden tener diferentes formatos y tipos de información.

• Importe el módulo viz

from viz import *

• Llame la función plot_data pasándole un diccionario de dataframes

plot_data(all_data)

En el widgent arriba los dropdowns hacen referencia a:

ds: dataset, proviene de un diccionario de datsets all_data.

Es posible agregar datasets adicionales al diccionario para visualizarlos.

A continuación una breve descripción de los dropdowns y opciones que proporciona el script.

• plot: el tipo de gráfico a construir.
• risk_it_all: por defecto False. Intenta cargar la variable en el campo adecuado de acuerdo al tipo de datos, categóricos o numéricos.
  • Si es marcado True carga todas las variables del dataset en todos los campos. Sabes lo que haces, sabes lo que buscas. Algunos gráficos devolverán error.
• De acuerdo al gráfico seleccionado puede activarse alguna de las opciones siguientes:

• x y y: Las variables que se representarán en los ejes x e y, respectivamente.

• hue: Una variable adicional que se utilizará para dividir los datos y colorear distintas categorías.
• col: Se activa para ciertos gráficos para realizar facceting. Se usa una variable categórica que se utilizará para dividir los datos en columnas separadas (subgráficos).
• kind: Tipo de gráfico, se activa para ciertos gráficos.

Replique el ejemplo a continuación:

from viz import *

all_data = {"Attrition": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/CHR_data.csv"),
            "Usability": pd.read_csv("https://raw.githubusercontent.com/marsgr6/EN-online/8a1cee296279c274d8f05f3905fce97c1f7636a2/data/UX_data.csv"),
            "Tips": sns.load_dataset("tips"),
            "Diamonds": sns.load_dataset("diamonds"),
            "MPG": sns.load_dataset("mpg"),
            "Iris": sns.load_dataset("iris"),
            "Geyser": sns.load_dataset("geyser"),
            "Penguins": sns.load_dataset("penguins"),
            "Titanic": sns.load_dataset("titanic")
           }

# Add additional dataframe to data dictionary
all_data["NY_collision"] = pd.read_csv("https://raw.githubusercontent.com/ResidentMario/missingno-data/master/nyc_collision_factors.csv")

plot_data(all_data)

interactive(children=(Dropdown(description='ds', options=('Attrition', 'Usability', 'Tips', 'Diamonds', 'MPG',…

• Como ejercicio, agregue datasets adicionales al diccionario y pruebe las diferentes opciones de visualización.

• Para agregar datasets puede hacerlo durante la definición de all_data arriba, vea como se ha agregado "Usability".

• O puede realizarlo posteriormente, vea el ejemplo:

  # Add dataframe to dictionary
  all_data["NY_collision"] = pd.read_csv("https://raw.githubusercontent.com/ResidentMario/missingno-data/master/nyc_collision_factors.csv")